home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / gedit-2 / plugins / externaltools / manager.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  12.8 KB  |  337 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = ('Manager',)
  5. import gedit
  6. import gtk
  7. import gtksourceview2 as gsv
  8. import os.path as os
  9. from library import *
  10. from functions import *
  11. import hashlib
  12.  
  13. class Singleton(object):
  14.     _instance = None
  15.     
  16.     def __new__(cls, *args, **kwargs):
  17.         if not cls._instance:
  18.             cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
  19.             cls._instance.__init_once__()
  20.         
  21.         return cls._instance
  22.  
  23.  
  24.  
  25. class Manager(Singleton):
  26.     LABEL_COLUMN = 0
  27.     NODE_COLUMN = 1
  28.     NAME_COLUMN = 1
  29.     
  30.     def __init__(self, datadir):
  31.         self.datadir = datadir
  32.  
  33.     
  34.     def __init_once__(self):
  35.         self.default_size = None
  36.         self.dialog = None
  37.  
  38.     
  39.     def build(self):
  40.         callbacks = {
  41.             'on_new_tool_button_clicked': self.on_new_tool_button_clicked,
  42.             'on_remove_tool_button_clicked': self.on_remove_tool_button_clicked,
  43.             'on_tool_manager_dialog_response': self.on_tool_manager_dialog_response,
  44.             'on_tool_manager_dialog_focus_out': self.on_tool_manager_dialog_focus_out,
  45.             'on_accelerator_key_press': self.on_accelerator_key_press,
  46.             'on_accelerator_focus_in': self.on_accelerator_focus_in,
  47.             'on_accelerator_focus_out': self.on_accelerator_focus_out }
  48.         self.ui = gtk.Builder()
  49.         self.ui.add_from_file(os.path.join(self.datadir, 'ui', 'tools.ui'))
  50.         self.ui.connect_signals(callbacks)
  51.         self.dialog = self.ui.get_object('tool-manager-dialog')
  52.         if self.default_size != None:
  53.             self.dialog.set_default_size(*self.default_size)
  54.         
  55.         self.view = self.ui.get_object('view')
  56.         for name in [
  57.             'input',
  58.             'output',
  59.             'applicability']:
  60.             self._Manager__init_combobox(name)
  61.         
  62.         self._Manager__init_tools_model()
  63.         self._Manager__init_tools_view()
  64.  
  65.     
  66.     def run(self):
  67.         if self.dialog == None:
  68.             self.build()
  69.             self.dialog.show()
  70.         else:
  71.             self.dialog.present()
  72.  
  73.     
  74.     def __init_tools_model(self):
  75.         self.tools = ToolLibrary()
  76.         self.current_node = None
  77.         self.script_hash = None
  78.         self.accelerators = dict()
  79.         self.model = gtk.ListStore(str, object)
  80.         self.view.set_model(self.model)
  81.         for item in self.tools.tree.tools:
  82.             self.model.append([
  83.                 item.name,
  84.                 item])
  85.             if item.shortcut:
  86.                 self.accelerators[item.shortcut] = item
  87.                 continue
  88.         
  89.  
  90.     
  91.     def __init_tools_view(self):
  92.         column = gtk.TreeViewColumn('Tools')
  93.         renderer = gtk.CellRendererText()
  94.         column.pack_start(renderer, False)
  95.         column.set_attributes(renderer, text = self.LABEL_COLUMN)
  96.         renderer.set_property('editable', True)
  97.         self.view.append_column(column)
  98.         renderer.connect('edited', self.on_view_label_cell_edited)
  99.         self.selection_changed_id = self.view.get_selection().connect('changed', self.on_view_selection_changed, None)
  100.  
  101.     
  102.     def __init_combobox(self, name):
  103.         combo = self[name]
  104.         combo.set_active(0)
  105.  
  106.     
  107.     def __getitem__(self, key):
  108.         return self.ui.get_object(key)
  109.  
  110.     
  111.     def set_active_by_name(self, combo_name, option_name):
  112.         combo = self[combo_name]
  113.         model = combo.get_model()
  114.         piter = model.get_iter_first()
  115.         while piter is not None:
  116.             if model.get_value(piter, self.NAME_COLUMN) == option_name:
  117.                 combo.set_active_iter(piter)
  118.                 return True
  119.             piter = model.iter_next(piter)
  120.             continue
  121.             model.get_value(piter, self.NAME_COLUMN) == option_name
  122.         return False
  123.  
  124.     
  125.     def get_selected_tool(self):
  126.         (model, piter) = self.view.get_selection().get_selected()
  127.         if piter is not None:
  128.             return (piter, model.get_value(piter, self.NODE_COLUMN))
  129.         return (None, None)
  130.  
  131.     
  132.     def compute_hash(self, string):
  133.         return hashlib.md5(string).hexdigest()
  134.  
  135.     
  136.     def save_current_tool(self):
  137.         if self.current_node is None:
  138.             return None
  139.         if self.current_node.filename is None:
  140.             self.current_node.autoset_filename()
  141.         
  142.         
  143.         def combo_value(o, name):
  144.             combo = o[name]
  145.             return combo.get_model().get_value(combo.get_active_iter(), self.NAME_COLUMN)
  146.  
  147.         self.current_node.input = combo_value(self, 'input')
  148.         self.current_node.output = combo_value(self, 'output')
  149.         self.current_node.applicability = combo_value(self, 'applicability')
  150.         self.current_node.comment = self['description'].get_text()
  151.         buf = self['commands'].get_buffer()
  152.         script = buf.get_text(*buf.get_bounds())
  153.         h = self.compute_hash(script)
  154.  
  155.     
  156.     def clear_fields(self):
  157.         self['description'].set_text('')
  158.         self['accelerator'].set_text('')
  159.         self['commands'].get_buffer().set_text('')
  160.         for nm in ('input', 'output', 'applicability'):
  161.             self[nm].set_active(0)
  162.         
  163.         self['title'].set_label(_('Edit tool <i>%s</i>:') % '')
  164.  
  165.     
  166.     def fill_fields(self):
  167.         node = self.current_node
  168.         self['description'].set_text(default(node.comment, _('A Brand New Tool')))
  169.         self['accelerator'].set_text(default(node.shortcut, ''))
  170.         buf = self['commands'].get_buffer()
  171.         script = default(''.join(node.get_script()), '')
  172.         buf.set_text(script)
  173.         self.script_hash = self.compute_hash(script)
  174.         contenttype = gio.content_type_guess(data = script)
  175.         lmanager = gedit.get_language_manager()
  176.         language = lmanager.guess_language(content_type = contenttype)
  177.         if language is not None:
  178.             buf.set_language(language)
  179.             buf.set_highlight_syntax(True)
  180.         else:
  181.             buf.set_highlight_syntax(False)
  182.         for nm in ('input', 'output', 'applicability'):
  183.             model = self[nm].get_model()
  184.             piter = model.get_iter_first()
  185.             self.set_active_by_name(nm, default(node.__getattribute__(nm), model.get_value(piter, self.NAME_COLUMN)))
  186.         
  187.         self['title'].set_label(_('Edit tool <i>%s</i>:') % node.name)
  188.  
  189.     
  190.     def on_new_tool_button_clicked(self, button):
  191.         self.save_current_tool()
  192.         self.view.get_selection().handler_block(self.selection_changed_id)
  193.         self.current_node = Tool(self.tools.tree)
  194.         self.current_node.name = _('New tool')
  195.         self.tools.tree.tools.append(self.current_node)
  196.         piter = self.model.append([
  197.             self.current_node.name,
  198.             self.current_node])
  199.         self.view.set_cursor(self.model.get_path(piter), self.view.get_column(self.LABEL_COLUMN), True)
  200.         self.fill_fields()
  201.         self['tool-table'].set_sensitive(True)
  202.         self.view.get_selection().handler_unblock(self.selection_changed_id)
  203.  
  204.     
  205.     def on_remove_tool_button_clicked(self, button):
  206.         (piter, node) = self.get_selected_tool()
  207.         if node.is_global():
  208.             if node.parent.revert_tool(node):
  209.                 if self.current_node.shortcut and self.current_node.shortcut in self.accelerator:
  210.                     del self.accelerators[self.current_node.shortcut]
  211.                 
  212.                 self['revert-tool-button'].set_sensitive(False)
  213.                 self.fill_fields()
  214.             
  215.         elif node.parent.delete_tool(node):
  216.             if self.current_node.shortcut:
  217.                 del self.accelerators[self.current_node.shortcut]
  218.             
  219.             self.current_node = None
  220.             self.script_hash = None
  221.             if self.model.remove(piter):
  222.                 self.view.set_cursor(self.model.get_path(piter), self.view.get_column(self.LABEL_COLUMN), False)
  223.                 self.view.grab_focus()
  224.             
  225.         
  226.  
  227.     
  228.     def on_view_label_cell_edited(self, cell, path, new_text):
  229.         if new_text != '':
  230.             piter = self.model.get_iter(path)
  231.             node = self.model.get_value(piter, self.NODE_COLUMN)
  232.             node.name = new_text
  233.             self.model.set(piter, self.LABEL_COLUMN, new_text)
  234.             self['title'].set_label(_('Edit tool <i>%s</i>:') % new_text)
  235.         
  236.  
  237.     
  238.     def on_view_selection_changed(self, selection, userdata):
  239.         print 'saving current tool'
  240.         self.save_current_tool()
  241.         (piter, node) = self.get_selected_tool()
  242.         if piter is not None and node is not None:
  243.             pass
  244.         removable = node.is_local()
  245.         self['remove-tool-button'].set_sensitive(removable)
  246.         self['revert-tool-button'].set_sensitive(removable)
  247.         if node is not None and node.is_global():
  248.             self['remove-tool-button'].hide()
  249.             self['revert-tool-button'].show()
  250.         else:
  251.             self['remove-tool-button'].show()
  252.             self['revert-tool-button'].hide()
  253.         if node is not None:
  254.             self.current_node = node
  255.             self.fill_fields()
  256.             self['tool-table'].set_sensitive(True)
  257.         else:
  258.             self.clear_fields()
  259.             self['tool-table'].set_sensitive(False)
  260.  
  261.     
  262.     def set_accelerator(self, keyval, mod):
  263.         if self.current_node.shortcut:
  264.             del self.accelerators[self.current_node.shortcut]
  265.         
  266.         name = gtk.accelerator_name(keyval, mod)
  267.         if name != '':
  268.             if name in self.accelerators:
  269.                 dialog = gtk.MessageDialog(self.dialog, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, _('This accelerator is already bound to %s') % self.accelerators[name].name)
  270.                 dialog.run()
  271.                 dialog.destroy()
  272.                 return False
  273.             self.current_node.shortcut = name
  274.             self.accelerators[name] = self.current_node
  275.         else:
  276.             self.current_node.shortcut = None
  277.         return True
  278.  
  279.     
  280.     def on_accelerator_key_press(self, entry, event):
  281.         mask = event.state & gtk.accelerator_get_default_mod_mask()
  282.         if event.keyval == gtk.keysyms.Escape:
  283.             entry.set_text(default(self.current_node.shortcut, ''))
  284.             self['commands'].grab_focus()
  285.             return True
  286.         if event.keyval == gtk.keysyms.Delete or event.keyval == gtk.keysyms.BackSpace:
  287.             entry.set_text('')
  288.             self.current_node.shortcut = None
  289.             self['commands'].grab_focus()
  290.             return True
  291.         if event.keyval in range(gtk.keysyms.F1, gtk.keysyms.F12 + 1):
  292.             self.set_accelerator(event.keyval, mask)
  293.             entry.set_text(default(self.current_node.shortcut, ''))
  294.             self['commands'].grab_focus()
  295.             return True
  296.         if gtk.gdk.keyval_to_unicode(event.keyval):
  297.             return True
  298.         return False
  299.  
  300.     
  301.     def on_accelerator_focus_in(self, entry, event):
  302.         if self.current_node is None:
  303.             return None
  304.         if self.current_node.shortcut:
  305.             entry.set_text(_('Type a new accelerator, or press Backspace to clear'))
  306.         else:
  307.             entry.set_text(_('Type a new accelerator'))
  308.  
  309.     
  310.     def on_accelerator_focus_out(self, entry, event):
  311.         if self.current_node is not None:
  312.             entry.set_text(default(self.current_node.shortcut, ''))
  313.         
  314.  
  315.     
  316.     def on_tool_manager_dialog_response(self, dialog, response):
  317.         if response == gtk.RESPONSE_HELP:
  318.             gedit.help_display(self.dialog, 'gedit', 'gedit-external-tools-plugin')
  319.             return None
  320.         self.on_tool_manager_dialog_focus_out(dialog, None)
  321.         self.default_size = [
  322.             self.dialog.allocation.width,
  323.             self.dialog.allocation.height]
  324.         self.dialog.destroy()
  325.         self.dialog = None
  326.         self.tools = None
  327.  
  328.     
  329.     def on_tool_manager_dialog_focus_out(self, dialog, event):
  330.         self.save_current_tool()
  331.         for window in gedit.app_get_default().get_windows():
  332.             helper = window.get_data('ExternalToolsPluginWindowData')
  333.             helper.menu.update()
  334.         
  335.  
  336.  
  337.